//1、ts中类的定义
class Person{
    name:string;    //属性    前面省略了public关键字
    constructor(n:string) { //构造函数  实例化类的时候触发的方法
        this.name = n;
    }
    run():void{
        alert(this.name);
    }
    getName():string{
        return this.name;
    }
    setName(name:string):void{
        this.name = name;
    }
}
var p = new Person("张三");
p.run();
p.setName("李四");
alert(p.getName());

//2、ts中实现继承     extends、super
class Person1{
    name:string;
    constructor(name:string) {
        this.name = name;
    }
    run():string{
        return `${this.name}在运动`
    }
}
var p1 = new Person('王五');
p1.run();
alert(p1.run());

class Web extends Person1{
    constructor(name:string) {
        super(name);//初始化父类的构造函数
    }
}
var w = new Web("李四");
w.run();

//3、ts中继承的探讨    父类的方法和子类的方法一致
class Person2{
    name:string;
    constructor(name:string) {
        this.name = name;
    }
    run():string{
        return `${this.name}在运动`
    }
}
var p2 = new Person('王五');
p2.run();
alert(p2.run());

class Web2 extends Person2{
    constructor(name:string) {
        super(name);//初始化父类的构造函数
    }
    run():string{
        return `${this.name}在运动-子类`;
    }
    work(){
        alert(`${this.name}在工作`);
    }
}
var w2 = new Web2("李四");
alert(w2.run());
alert(w2.work());

//3、类里面的修饰符 typescript里面定义属性提供了三种修饰符
/**
 * public:公有，在类里面、子类、类外面都可以访问
 * protected:保护类型，在类里面、子类里面可以访问，在类外部没法访问
 * private:私有，在类里面可以访问，在子类和类外部都没法访问
 *
 * 属性不加修饰符，默认公有
 */
class Person3{
    public name:string;//公有属性

    constructor(name:string) {
        this.name = name;
    }

    run():string{
        return `${this.name}在运动`;
    }
}

class Web3 extends Person{
    constructor(name:string) {
        super(name);//初始化父类构造函数
    }
    run():string{
        return `${this.name}在运动-子类`;
    }
    work(){
        alert(`${this.name}在工作-子类`);
    }
}
var w3 = new Web3('李四')
w3.work();

//protected:保护类型    在类里面、子类里面可以访问，在类外部没法访问
class Person4{
    protected name:string;

    constructor(name:string) {
        this.name = name;
    }

    run():string{
        return `${this.name}在运动`;
    }
}

class Web4 extends Person{
    constructor(name:string) {
        super(name);//初始化父类构造函数
    }
    work(){
        alert(`${this.name}在工作-子类`);
    }
}
var w4 = new Web4('李四111')
alert(w4.work());
alert(w4.run());

//4、静态属性、静态方法
/*function Person5(){
    this.run1 = function (){

    }
}
Person5.name = '哈哈哈';//静态属性
Person5.run2 = function () {//静态方法

}
var p5 = new Person5();
Person5.run2();*/
//typescript
class Person5 {
    public name:string;
    constructor(name:string) {
        this.name = name;
    }

    run(){//实例方法
        alert(`${this.name}在运动`);
    }

    work(){
        alert(`${this.name}在工作`);
    }
    static print(){//静态方法   里面没法直接调用类里面的属性，只能调用静态属性
        alert('print方法');
    }
}
var p5 = new Person5('张三');
p5.run();//调用实例方法
Person5.print();//调用静态方法

//多态:父类定义一个方法不去实现，让继承它的子类去实现，每一个子类有不同的表现
//多态属于继承
class Animal {
    name:string;
    constructor(name:string) {
        this.name = name;
    }
    eat(){
        console.log('吃的方法');//具体吃什么不知道  具体吃什么继承它的子类去实现，每个子类表现不一样
    }
}
class Dog extends Animal{
    constructor(name:string) {
        super(name);
    }
    eat() {
        return this.name + '吃肉';
    }
}
class Cat extends Animal{
    constructor(name:string) {
        super(name);
    }
    eat() {
        return this.name + '吃鱼';
    }
}

//typescript中的抽象类:它是提供给其它类继承的基类，不能直接被实例化
//用abstract关键字定义抽象类和抽象方法，抽象类中的抽象方法不包含具体的实现，必须在派生类中实现
















